/**
 * 字典数据缓存管理
 * 内存级别的缓存，应用重启后清空
 */
import type { DictionaryItem, BatchDictionaryResponse } from '../api/resource'
import { getDictionaryDatasByTypeKey, getDictionaryDatasByTypeKeys } from '../api/resource'

class DictionaryCacheManager {
  // 字典数据缓存，key 为 typeKey
  private cache: Map<string, DictionaryItem[]> = new Map()
  
  /**
   * 获取字典数据缓存
   */
  get(typeKey: string): DictionaryItem[] | null {
    return this.cache.get(typeKey) || null
  }
  
  /**
   * 设置字典数据缓存
   */
  set(typeKey: string, data: DictionaryItem[]): void {
    // 按 sort 字段排序
    const sortedData = data.sort((a, b) => a.sort - b.sort)
    this.cache.set(typeKey, sortedData)
  }
  
  /**
   * 获取字典数据（带缓存）
   * 如果缓存存在则返回缓存，否则请求接口并缓存
   */
  async load(typeKey: string): Promise<DictionaryItem[]> {
    // 先从缓存获取
    const cached = this.get(typeKey)
    if (cached) {
      return cached
    }
    
    // 缓存不存在，请求接口
    try {
      const data = await getDictionaryDatasByTypeKey(typeKey)
      this.set(typeKey, data)
      return data
    } catch (error) {
      console.error(`加载字典数据失败 (typeKey: ${typeKey}):`, error)
      return []
    }
  }
  
  /**
   * 批量加载字典数据（带缓存）
   * 只请求缓存中不存在的字典数据
   */
  async loadBatch(typeKeys: string[]): Promise<BatchDictionaryResponse> {
    // 筛选出需要请求的 typeKeys（缓存中不存在的）
    const missingTypeKeys: string[] = []
    const result: BatchDictionaryResponse = {}
    
    // 先从缓存获取
    for (const typeKey of typeKeys) {
      const cached = this.get(typeKey)
      if (cached) {
        result[typeKey] = cached
      } else {
        missingTypeKeys.push(typeKey)
      }
    }
    
    // 如果所有数据都在缓存中，直接返回
    if (missingTypeKeys.length === 0) {
      return result
    }
    
    // 请求缺失的字典数据
    try {
      const data = await getDictionaryDatasByTypeKeys(missingTypeKeys)
      
      // 缓存新获取的数据
      for (const typeKey in data) {
        this.set(typeKey, data[typeKey])
        result[typeKey] = data[typeKey]
      }
      
      return result
    } catch (error) {
      console.error('批量加载字典数据失败:', error)
      return result
    }
  }
  
  /**
   * 获取字典数据的value数组（用于选择器）
   */
  getValues(typeKey: string): string[] {
    const data = this.get(typeKey)
    if (!data) {
      return []
    }
    return data.map(item => item.value)
  }
  
  /**
   * 根据 dataKey 获取字典项的 value
   */
  getValueByKey(typeKey: string, dataKey: string): string {
    const data = this.get(typeKey)
    if (!data) {
      return dataKey
    }
    const item = data.find(d => d.dataKey === dataKey)
    return item ? item.value : dataKey
  }
  
  /**
   * 根据 dataKey 获取字典项
   */
  getItemByKey(typeKey: string, dataKey: string): DictionaryItem | null {
    const data = this.get(typeKey)
    if (!data) {
      return null
    }
    return data.find(d => d.dataKey === dataKey) || null
  }
  
  /**
   * 清空所有缓存
   */
  clear(): void {
    this.cache.clear()
  }
  
  /**
   * 清空指定类型的缓存
   */
  clearByType(typeKey: string): void {
    this.cache.delete(typeKey)
  }
}

// 导出单例
export const dictionaryCache = new DictionaryCacheManager()

// 常用字典类型常量
export const DictionaryType = {
  // 公司性质
  COMPANY_NATURE: 'company_nature',
  // 人员规模
  STAFF_SIZE: 'staff_size',
  // 加班情况
  OVERTIME_SITUATION: 'overtime_situation',
  // 休息时间
  REST_TIME: 'rest_time',
  // 公司优势
  COMPANY_ADVANTAGE: 'company_advantage',
  // 福利待遇
  COMPANY_WELFARE: 'company_welfare',
  // 薪资福利
  SALARY_BENEFIT: 'salary_benefit',
  // 补助津贴
  SUBSIDY_ALLOWANCE: 'subsidy_allowance',
  // 融资阶段
  FINANCING_STATUS: 'financing_status',
  // HR 个性标签 - 个人身份
  HR_TAG_IDENTITY: 'hr_tag_identity',
  // HR 个性标签 - 管理风格
  HR_TAG_MANAGEMENT_STYLE: 'hr_tag_management_style',
  // HR 个性标签 - 性格特点
  HR_TAG_PERSONALITY: 'hr_tag_personality',
}


